Efficient Single Writer Concurrency

In this paper we consider single writer multiple reader concurrency—any number of transactions can atomically access shared data structures, but only one thread can atomically update the data. Limiting ourselves to a single writer allows us to achieve strong properties, some of which are not achievable with multiple writers. In particular, we guarantee strict serializability, no aborts, wait-freedom with strong bounds on step complexity, and precise garbage collection. Even with a single writer, achieving many of these properties is non-trivial. Our approach is based on a variant of multiversion concurrency control. In particular, the user code accesses shared data in a purely functional manner, which does not support modifying existing data. This allows each read to get a snapshot of the current database. The writer simply swaps in a new root in order to commit a new version. For garbage collection, we define the version maintenance problem and present efficient algorithms that solve it. This framework allows for very low overhead for maintaining and collecting multiple versions. The single-writer setup is particularly applicable to search indices, online graph analysis, and hybrid transactional/analytical processing (HTAP) databases, in which the bulk of the work is done by transactions that analyze the data. We have implemented the approach in C++ based on a parallel library PAM on balanced binary trees. We present results for two use cases. The first is doing concurrent range-sum queries on a database while new elements are continually added to it. The second is a search index on a corpus, which also supports adding new documents to the database. Experiments show that in both cases there is very little overhead when adding a single writer running in the background, while the queries can gradually get newly updated versions. Also, using our lock-free algorithm for version maintenance, the maximum live versions is bounded by the number of working transactions at the same time.